from typing import List, Dict, Tuple
import os
from .models import FileInfo, CategoryStats
from config.categories import CATEGORY_RULES, SIZE_CATEGORIES

class FileClassifier:
    """文件分类器"""
    
    def __init__(self):
        self.category_stats: Dict[str, CategoryStats] = {}
        self._initialize_category_stats()
        # 创建扩展名到类别的映射，提高查找效率
        self._extension_to_category = {}
        self._initialize_extension_mapping()
    
    def _initialize_extension_mapping(self):
        """初始化扩展名到类别的映射字典"""
        for category, extensions in CATEGORY_RULES.items():
            for ext in extensions:
                self._extension_to_category[ext] = category
    
    def get_file_type(self, file_path: str) -> str:
        """获取文件类型
        
        Args:
            file_path: 文件路径
        
        Returns:
            文件类型（扩展名）
        """
        _, extension = os.path.splitext(file_path)
        return extension.lower()
    
    def _initialize_category_stats(self):
        """初始化分类统计"""
        for category in CATEGORY_RULES.keys():
            self.category_stats[category] = CategoryStats(category_name=category)
        self.category_stats['其他'] = CategoryStats(category_name='其他')
        self.category_stats['目录'] = CategoryStats(category_name='目录')
        # 添加大小分类
        for size_category in SIZE_CATEGORIES.keys():
            self.category_stats[size_category] = CategoryStats(category_name=size_category)
    
    def classify_files(self, file_list: List[FileInfo]) -> Dict[str, List[FileInfo]]:
        """对文件列表进行分类
        
        Args:
            file_list: 文件信息列表
        
        Returns:
            按类别分组的文件字典
        """
        classified_files = {category: [] for category in self.category_stats.keys()}
        
        for file_info in file_list:
            category = self._classify_single_file(file_info)
            file_info.category = category
            classified_files[category].append(file_info)
            
            # 更新分类统计
            if not file_info.is_directory:
                stats = self.category_stats[category]
                stats.file_count += 1
                stats.total_size += file_info.size
        
        # 计算平均文件大小
        for stats in self.category_stats.values():
            if stats.file_count > 0:
                stats.avg_file_size = stats.total_size / stats.file_count
        
        return classified_files
    
    def _classify_single_file(self, file_info: FileInfo) -> str:
        """对单个文件进行分类
        
        Args:
            file_info: 文件信息对象
        
        Returns:
            分类类别名称
        """
        if file_info.is_directory:
            return "目录"
        
        # 基于扩展名分类 - 使用映射字典，O(1)查找复杂度
        category = self._extension_to_category.get(file_info.extension)
        if category:
            return category
        
        # 基于文件大小分类
        size_category = self._classify_by_size(file_info.size)
        if size_category:
            return size_category
        
        return "其他"
    
    def _classify_by_size(self, size: int) -> str:
        """基于文件大小分类
        
        Args:
            size: 文件大小（字节）
        
        Returns:
            大小分类名称
        """
        for category, (min_size, max_size) in SIZE_CATEGORIES.items():
            if min_size <= size < max_size:
                return category
        return ""
    
    def get_size_category(self, size: int) -> str:
        """获取文件大小分类
        
        Args:
            size: 文件大小（字节）
        
        Returns:
            大小分类名称
        """
        return self._classify_by_size(size)
    
    def get_category_statistics(self) -> List[CategoryStats]:
        """获取分类统计信息
        
        Returns:
            分类统计列表
        """
        return list(self.category_stats.values())